การสนทนากับ Gemini

import { runBrisque, runPsnr, runSsim } from '../api';
import { markStartThenRunning, fetchFileFromUrl, getNodeImageUrl, updateNodeStatus, findInputImage } from './utils';
import type { Edge } from 'reactflow';
import type { RFNode, SetNodes } from './utils';
import type { CustomNodeData } from '../../types';

export async function runQuality(
  node: RFNode,
  setNodes: SetNodes,
  nodes: RFNode[],
  edges: Edge[]
) {
  const getIncoming = (id: string) => edges.filter((e) => e.target === id);

  // Helper: Throw & Update Fault
  const fail = async (msg: string) => {
    await updateNodeStatus(node.id, 'fault', setNodes);
    throw new Error(msg);
  };

  // -----------------------------------------------------
  // 🛡️ BRISQUE (ต้องการ Image บริสุทธิ์)
  // -----------------------------------------------------
  if (node.type === 'brisque') {
    const incoming = getIncoming(node.id);
    if (incoming.length < 1) return fail('No image input');

    const prevNode = nodes.find((n) => n.id === incoming[0].source);
    const BAD_SOURCES = ['sift', 'surf', 'orb', 'bfmatcher', 'flannmatcher', 'otsu', 'snake'];

    // ✅ เพิ่ม Validation: ดักจับ Feature/Matcher/Classification
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      return fail(`Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`);
    }

    const imgUrl = findInputImage(node.id, nodes, edges);

    if (!imgUrl) return fail('Image URL not found for processing.');

    await markStartThenRunning(node.id, 'Running BRISQUE', setNodes);

    try {
      const resp = await runBrisque(imgUrl);

      setNodes((nds) =>
        nds.map((x) =>
          x.id === node.id
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: `BRISQUE = ${Number(resp.score).toFixed(2)}`,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    quality_score: resp.score,
                    json: resp,
                    output: resp // ส่งต่อ JSON ผลลัพธ์
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'BRISQUE failed');
    }
    return;
  }

  // -----------------------------------------------------
  // 🛡️ PSNR / SSIM (ต้องการ 2 Images)
  // -----------------------------------------------------
  if (node.type === 'psnr' || node.type === 'ssim') {
    const incoming = getIncoming(node.id);
    const e1 = incoming.find((e) => e.targetHandle === 'input1');
    const e2 = incoming.find((e) => e.targetHandle === 'input2');

    if (!e1 || !e2) return fail('Need two image inputs (Input 1 & Input 2)');

    const nodeA = nodes.find((x) => x.id === e1.source);
    const nodeB = nodes.find((x) => x.id === e2.source);

    const urlA = getNodeImageUrl(nodeA);
    const urlB = getNodeImageUrl(nodeB);

    if (!urlA || !urlB) return fail('Image URL for one or both inputs missing.');

    await markStartThenRunning(node.id, `Running ${node.type.toUpperCase()}`, setNodes);

    try {
      const fileA = await fetchFileFromUrl(urlA, 'a.jpg');
      const fileB = await fetchFileFromUrl(urlB, 'b.jpg');

      const runner = node.type === 'psnr' ? runPsnr : runSsim;
      const resp = await runner(fileA, fileB);

      const desc =
        node.type === 'psnr'
          ? `PSNR = ${Number(resp.quality_score ?? resp.score).toFixed(2)} dB`
          : `SSIM = ${Number(resp.score).toFixed(4)}`;

      setNodes((nds) =>
        nds.map((x) =>
          x.id === node.id
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: desc,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'Metric failed');
    }
  }
}

// src/components/nodes/SsimNode.tsx
import { memo, useCallback, useMemo } from 'react';
import { Handle, Position, type NodeProps, useEdges } from 'reactflow';
import type { CustomNodeData } from '../../types';

const statusDot = (active: boolean, color: string) =>
  `h-4 w-4 rounded-full ${active ? color : 'bg-gray-600'} flex-shrink-0 shadow-inner`;

const SsimNode = memo(({ id, data, selected }: NodeProps<CustomNodeData>) => {
  const edges = useEdges(); // ✅ ใช้ edges ตรงๆ
  
  const isConnected1 = useMemo(() => edges.some(e => e.target === id && e.targetHandle === 'input1'), [edges, id]);
  const isConnected2 = useMemo(() => edges.some(e => e.target === id && e.targetHandle === 'input2'), [edges, id]);

  const isRunning = data?.status === 'start' || data?.status === 'running';
  const isFault = data?.status === 'fault';

  const handleRun = useCallback(() => {
    if (isRunning) return;
    data?.onRunNode?.(id);
  }, [data, id, isRunning]);

  const val = data?.payload?.json?.score;
  const caption =
    (typeof data?.description === 'string' && data.description) ||
    (typeof val === 'number' ? `SSIM = ${val.toFixed(4)}` : 'No score yet');

  let borderColor = 'border-blue-500';
  if (selected) {
    borderColor = 'border-blue-400 ring-2 ring-blue-500';
  } else if (isRunning) {
    borderColor = 'border-yellow-500 ring-2 ring-yellow-500/50';
  }

  const getHandleClass = (connected: boolean) => `w-2 h-2 rounded-full border-2 transition-all duration-300 ${
    isFault && !connected
      ? '!bg-red-500 !border-red-300 !w-4 !h-4 shadow-[0_0_10px_rgba(239,68,68,1)] ring-4 ring-red-500/30'
      : 'bg-white border-gray-500'
  }`;

  return (
    <div className={`bg-gray-800 border-2 rounded-xl shadow-2xl w-72 text-gray-200 transition-all duration-200 ${borderColor}`}>
      
      {/* Input 1 */}
      <Handle 
        type="target" 
        position={Position.Left} 
        id="input1" 
        className={getHandleClass(isConnected1)} 
        style={{ top: '35%', transform: 'translateY(-50%)' }} 
      />
      
      {/* Input 2 */}
      <Handle 
        type="target" 
        position={Position.Left} 
        id="input2" 
        className={getHandleClass(isConnected2)} 
        style={{ top: '65%', transform: 'translateY(-50%)' }} 
      />
      
      {/* Output (Right) */}
      <Handle 
        type="source" 
        position={Position.Right} 
        id="json" 
        className={getHandleClass(true)} 
        style={{ top: '50%', transform: 'translateY(-50%)' }} 
      />

      <div className="bg-gray-700 text-blue-400 rounded-t-xl px-2 py-2 flex items-center justify-between">
        <div className="font-bold">SSIM</div>
        <button
          title="Run this node"
          onClick={handleRun}
          disabled={isRunning}
          className={[
            'px-2 py-1 rounded text-xs font-semibold transition-colors duration-200 text-white',
            isRunning ? 'bg-yellow-600 cursor-wait opacity-80' : 'bg-blue-600 hover:bg-blue-700',
          ].join(' ')}
        >
          {isRunning ? 'Running...' : '▶ Run'}
        </button>
      </div>

      <div className="p-4 space-y-2">
        <p className="text-sm text-gray-300">{caption}</p>
        {typeof val === 'number' && (
          <div className="text-[11px] text-gray-400">Closer to 1.0 is better</div>
        )}
      </div>

      <div className="border-t-2 border-gray-700 p-2 text-sm">
        <div className="flex justify-between items-center py-1">
          <span className="text-red-400">start</span>
          <div className={statusDot(data?.status === 'start', 'bg-red-500')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-cyan-400">running</span>
          <div className={statusDot(data?.status === 'running', 'bg-cyan-400 animate-pulse')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-green-400">success</span>
          <div className={statusDot(data?.status === 'success', 'bg-green-500')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-yellow-400">fault</span>
          <div className={statusDot(data?.status === 'fault', 'bg-yellow-500')} />
        </div>
      </div>
    </div>
  );
});

export default SsimNode;

// src/components/nodes/PSNRNode.tsx
import { memo, useCallback, useMemo } from 'react';
import { Handle, Position, type NodeProps, useEdges } from 'reactflow'; // ✅ ใช้ useEdges
import type { CustomNodeData } from '../../types';

const statusDot = (active: boolean, color: string) =>
  `h-4 w-4 rounded-full ${active ? color : 'bg-gray-600'} flex-shrink-0 shadow-inner`;

const PSNRNode = memo(({ id, data, selected }: NodeProps<CustomNodeData>) => {
  const edges = useEdges(); // ✅ ใช้ edges ตรงๆ

  const isConnected1 = useMemo(() => edges.some(e => e.target === id && e.targetHandle === 'input1'), [edges, id]);
  const isConnected2 = useMemo(() => edges.some(e => e.target === id && e.targetHandle === 'input2'), [edges, id]);

  const isRunning = data?.status === 'start' || data?.status === 'running';
  const isFault = data?.status === 'fault';

  const handleRun = useCallback(() => {
    if (isRunning) return;
    data?.onRunNode?.(id);
  }, [data, id, isRunning]);

  const val = data?.payload?.json?.quality_score;
  const caption =
    (typeof data?.description === 'string' && data.description) ||
    (typeof val === 'number' ? `PSNR = ${val.toFixed(2)} dB` : 'No score yet');

  let borderColor = 'border-blue-500';
  if (selected) {
    borderColor = 'border-blue-400 ring-2 ring-blue-500';
  } else if (isRunning) {
    borderColor = 'border-yellow-500 ring-2 ring-yellow-500/50';
  }

  const getHandleClass = (connected: boolean) => `w-2 h-2 rounded-full border-2 transition-all duration-300 ${
    isFault && !connected
      ? '!bg-red-500 !border-red-300 !w-4 !h-4 shadow-[0_0_10px_rgba(239,68,68,1)] ring-4 ring-red-500/30'
      : 'bg-white border-gray-500'
  }`;

  return (
    <div className={`bg-gray-800 border-2 rounded-xl shadow-2xl w-72 text-gray-200 transition-all duration-200 ${borderColor}`}>
      
      {/* Input 1 */}
      <Handle 
        type="target" 
        position={Position.Left} 
        id="input1" 
        className={getHandleClass(isConnected1)} 
        style={{ top: '35%', transform: 'translateY(-50%)' }} 
      />
      
      {/* Input 2 */}
      <Handle 
        type="target" 
        position={Position.Left} 
        id="input2" 
        className={getHandleClass(isConnected2)} 
        style={{ top: '65%', transform: 'translateY(-50%)' }} 
      />
      
      {/* Output (Right) */}
      <Handle 
        type="source" 
        position={Position.Right} 
        id="json" 
        className={getHandleClass(true)} 
        style={{ top: '50%', transform: 'translateY(-50%)' }} 
      />

      <div className="bg-gray-700 text-blue-400 rounded-t-xl px-2 py-2 flex items-center justify-between">
        <div className="font-bold">PSNR</div>
        <button
          title="Run this node"
          onClick={handleRun}
          disabled={isRunning}
          className={[
            'px-2 py-1 rounded text-xs font-semibold transition-colors duration-200 text-white',
            isRunning

import { runBrisque, runPsnr, runSsim } from '../api';
import { markStartThenRunning, fetchFileFromUrl, getNodeImageUrl, updateNodeStatus, findInputImage } from './utils';
import type { Edge } from 'reactflow';
import type { RFNode, SetNodes } from './utils';
import type { CustomNodeData } from '../../types';

export async function runQuality(
  node: RFNode,
  setNodes: SetNodes,
  nodes: RFNode[],
  edges: Edge[]
) {
  const nodeId = node.id; // ดึง ID ออกมาใช้ใน Scope
  const getIncoming = (id: string) => edges.filter((e) => e.target === id);

  // ✅ Helper: Throw & Update Fault (นิยามใน Scope เพื่อเข้าถึง nodeId/setNodes ได้)
  const fail = async (msg: string) => {
    await updateNodeStatus(nodeId, 'fault', setNodes);
    throw new Error(msg); 
  };

  // -----------------------------------------------------
  // 🛡️ BRISQUE (ต้องการ Image บริสุทธิ์)
  // -----------------------------------------------------
  if (node.type === 'brisque') {
    const incoming = getIncoming(nodeId);
    if (incoming.length < 1) return fail('No image input');

    const prevNode = nodes.find((n) => n.id === incoming[0].source);
    const BAD_SOURCES = ['sift', 'surf', 'orb', 'bfmatcher', 'flannmatcher', 'otsu', 'snake'];

    // ✅ Validation: ดักจับ Feature/Matcher/Classification
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      await fail(`Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`);
      return;
    }

    const imgUrl = findInputImage(nodeId, nodes, edges);

    if (!imgUrl) return fail('Image URL not found for processing.');

    await markStartThenRunning(nodeId, 'Running BRISQUE', setNodes);

    try {
      // API call
      const resp = await runBrisque(imgUrl);

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: `BRISQUE = ${Number(resp.score).toFixed(2)}`,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    quality_score: resp.score,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      // Log Panel จะได้รับ error จาก fail() ที่ถูกเรียกใช้
      await fail(err?.message || 'BRISQUE failed');
      return; 
    }
    return;
  }

  // -----------------------------------------------------
  // 🛡️ PSNR / SSIM (ต้องการ 2 Images)
  // -----------------------------------------------------
  if (node.type === 'psnr' || node.type === 'ssim') {
    const incoming = getIncoming(nodeId);
    const e1 = incoming.find((e) => e.targetHandle === 'input1');
    const e2 = incoming.find((e) => e.targetHandle === 'input2');

    if (!e1 || !e2) return fail('Need two image inputs (Input 1 & Input 2)');

    const nodeA = nodes.find((x) => x.id === e1.source);
    const nodeB = nodes.find((x) => x.id === e2.source);

    // ใช้ getNodeImageUrl จาก utils.tsx
    const urlA = getNodeImageUrl(nodeA);
    const urlB = getNodeImageUrl(nodeB);

    if (!urlA || !urlB) return fail('Image URL for one or both inputs missing.');

    await markStartThenRunning(nodeId, `Running ${node.type.toUpperCase()}`, setNodes);

    try {
      // แปลง URL → File เพื่อส่ง multipart ให้ API
      const fileA = await fetchFileFromUrl(urlA, 'a.jpg');
      const fileB = await fetchFileFromUrl(urlB, 'b.jpg');

      const runner = node.type === 'psnr' ? runPsnr : runSsim;
      const resp = await runner(fileA, fileB);

      const desc =
        node.type === 'psnr'
          ? `PSNR = ${Number(resp.quality_score ?? resp.score).toFixed(2)} dB`
          : `SSIM = ${Number(resp.score).toFixed(4)}`;

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: desc,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      // Log Panel จะได้รับ error จาก fail() ที่ถูกเรียกใช้
      await fail(err?.message || 'Metric failed');
      return;
    }
  }
}

// src/lib/runners/utils.tsx

import type { RFNode, CustomNodeData } from '../../types'; 
import type { Edge } from 'reactflow';

// ... (ฟังก์ชันอื่นๆ เช่น updateNodeStatus, markStartThenRunning, fetchFileFromUrl ควรถูก export ที่นี่) 
// **สำคัญ:** อย่าลืม export ทุกฟังก์ชันที่คุณใช้ใน quality.tsx

// ------------------------------------------------------------------
// 1. Helper สำหรับดึง URL รูปภาพจาก Node เดียว (แก้ไขจุดบอด)
// ------------------------------------------------------------------
export function getNodeImageUrl(n?: RFNode): string | undefined {
    if (!n) return undefined;
    const p = (n.data as CustomNodeData)?.payload;

    if (!p) return undefined;

    // A. Priority 1: Image Input & Alignment Nodes (ใช้ URL ที่เป็นรูปภาพชัดเจน)
    if (n.type === 'image-input') {
        return p.url;
    }
    if (n.type === 'alignment') {
        // Alignment outputs an 'aligned_url' and sometimes 'url' (if a mask is used)
        return p.aligned_url ?? p.url;
    }

    // B. Priority 2: Segmentation/Classification/General Output (ใช้ URL ของผลลัพธ์ที่เป็นรูป)
    if (n.type === 'otsu' || n.type === 'snake') {
        // Otsu/Snake output a mask/binary image
        return p.result_image_url ?? p.mask_url ?? p.url;
    }

    // C. Priority 3: Fallback (สำหรับโหนดอื่นๆ ที่อาจมีรูปภาพ เช่น Saver)
    // ตรวจสอบคีย์ทั่วไป
    return p.url ?? p.saved_path ?? p.path ?? p.vis_url;
}

// ------------------------------------------------------------------
// 2. ฟังก์ชันหลักในการค้นหารูปภาพจาก upstream node (สำหรับ BRISQUE)
// ------------------------------------------------------------------
export function findInputImage(
    targetNodeId: string, 
    nodes: RFNode[], 
    edges: Edge[], 
    handleId?: string // มักจะเป็น undefined สำหรับ BRISQUE
): string | undefined {
    
    // 1. กรองหาเส้นเชื่อมเข้า
    const incomingEdges = edges.filter(e => e.target === targetNodeId && (!handleId || e.targetHandle === handleId));

    if (incomingEdges.length === 0) {
        return undefined; // ไม่มี Input
    }

    // 2. หา Source Node
    const sourceNodeId = incomingEdges[0].source;
    const sourceNode = nodes.find(n => n.id === sourceNodeId);

    // 3. ดึง URL รูปภาพจาก Source Node
    const url = getNodeImageUrl(sourceNode);

    if (!url) {
        console.error(`[findInputImage] No image URL found in upstream node ${sourceNodeId}.`);
    }

    return url;
}

# server/algos/quality/brisque_adapter.py
import os
import json
import cv2
import numpy as np
import uuid
from typing import Optional, Tuple, Dict, Any

# ... (ส่วน Config และ _to_uint8_gray เหมือนเดิม) ...

def run(image_path: str, out_root: Optional[str] = None) -> Tuple[str, Dict[str, Any]]:
   
    # ---------------------------------------------------------
    # 1. VALIDATION: ป้องกันการรับไฟล์ JSON จากโหนดอื่น
    # ---------------------------------------------------------
    if image_path.lower().endswith(".json"):
        try:
            with open(image_path, 'r', encoding='utf-8') as f:
                meta = json.load(f)
            
            # เช็คว่าเป็นไฟล์ผลลัพธ์จากเครื่องมืออื่นหรือไม่ (Feature/Matching/Alignment)
            tool = meta.get("tool") or meta.get("matching_tool") or meta.get("alignment_tool")
            
            if tool:
                # ถ้าเจอว่ามี tool name อยู่ใน JSON แสดงว่าไม่ใช่รูปภาพบริสุทธิ์
                raise ValueError(
                    f"Invalid Input: Received a '{tool}' result file. "
                    "BRISQUE requires an Image file (JPG/PNG), not a JSON result."
                )
        except (json.JSONDecodeError, FileNotFoundError, PermissionError):
            # ถ้าอ่าน JSON ไม่ได้ หรือไฟล์ไม่น่าสงสัย ก็ปล่อยให้ cv2.imread จัดการต่อ
            pass 

    # ---------------------------------------------------------
    # 2. Load Image (ใช้โค้ดเดิม)
    # ---------------------------------------------------------
    img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
    
    if img is None:
        raise ValueError(f"Cannot read image: {image_path} (File might not be an image)")

    gray = _to_uint8_gray(img, image_path)

    # Guard small images (statistics may be unstable)
    h, w = gray.shape[:2]
    if min(h, w) < 48:
        raise ValueError(f"Image too small for stable BRISQUE (got {w}x{h}); please use >= 48x48.")
        
    # ... (ส่วนอื่น ๆ ของการคำนวณและ Save JSON เหมือนเดิม) ...

    # 5. Save JSON
    # ... (Code to set out_dir, unique_id, out_json) ...

    data: Dict[str, Any] = {
        # ... (Output data structure) ...
        "quality_score": score_rounded,
        "quality_bucket": score_bucket
    }

    with open(out_json, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

    return out_json, data

import os
import sys
import json
import uuid
from typing import Optional, Tuple, Dict, Any

import cv2
import numpy as np


# --- Config ---
PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
MODEL_PATH = os.path.join(PROJECT_ROOT, "server/algos/quality/brisque_models/brisque_model_live.yml")
RANGE_PATH = os.path.join(PROJECT_ROOT, "server/algos/quality/brisque_models/brisque_range_live.yml")


def _to_uint8_gray(img: np.ndarray, image_path: str) -> np.ndarray:
    
    if img is None:
        raise ValueError(f"Cannot read image: {image_path}")

    # Convert to grayscale depending on channels
    if img.ndim == 2:
        gray = img
    elif img.ndim == 3:
        ch = img.shape[2]
        if ch == 3:
            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        elif ch == 4:
            gray = cv2.cvtColor(img, cv2.COLOR_BGRA2GRAY)
        else:
            raise ValueError(f"Unsupported channel count ({ch}) in image: {image_path}")
    else:
        raise ValueError(f"Unsupported image shape {img.shape}: {image_path}")

    # Ensure uint8
    if gray.dtype == np.uint8:
        return gray
    if gray.dtype == np.uint16:
        # 16-bit to 8-bit (approx): divide by 257
        return (gray / 257).astype(np.uint8)
    if gray.dtype in (np.float32, np.float64):
        gmin, gmax = float(gray.min()), float(gray.max())
        if gmax > gmin:
            out = (gray - gmin) / (gmax - gmin)
            return np.clip(out * 255.0, 0, 255).astype(np.uint8)
        # All pixels equal → return zeros
        return np.zeros_like(gray, dtype=np.uint8)

    # Fallback: cast
    return gray.astype(np.uint8)


def _interpret_brisque(score: float) -> str:
    
    if score < 15:
        return "excellent"
    if score < 25:
        return "good"
    if score < 40:
        return "fair"
    if score < 60:
        return "poor"
    return "very_poor"


def run(image_path: str, out_root: Optional[str] = None) -> Tuple[str, Dict[str, Any]]:
   
    # ---------------------------------------------------------
    # 1. VALIDATION: ป้องกันการรับไฟล์ JSON จากโหนดอื่น
    # ---------------------------------------------------------
    if image_path.lower().endswith(".json"):
        try:
            with open(image_path, 'r', encoding='utf-8') as f:
                meta = json.load(f)
            
            # เช็คว่าเป็นไฟล์ผลลัพธ์จากเครื่องมืออื่นหรือไม่
            tool = meta.get("tool") or meta.get("matching_tool") or meta.get("alignment_tool")
            
            if tool:
                # ถ้าเจอว่ามี tool name อยู่ใน JSON แสดงว่าไม่ใช่รูปภาพบริสุทธิ์
                raise ValueError(
                    f"Invalid Input: Received a '{tool}' result file. "
                    "BRISQUE requires an Image file (JPG/PNG), not a JSON result."
                )
        except (json.JSONDecodeError, FileNotFoundError, PermissionError):
            pass 

    # ---------------------------------------------------------
    # 2. Load Image
    # ---------------------------------------------------------
    img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
    
    if img is None:
        raise ValueError(f"Cannot read image: {image_path} (File might not be an image)")

    gray = _to_uint8_gray(img, image_path)

    # Guard small images (statistics may be unstable)
    h, w = gray.shape[:2]
    if min(h, w) < 48:
        raise ValueError(f"Image too small for stable BRISQUE (got {w}x{h}); please use >= 48x48. Path={image_path}")

    # ---------------------------------------------------------
    # 3. Ensure model files exist
    # ---------------------------------------------------------
    if not os.path.exists(MODEL_PATH) or not os.path.exists(RANGE_PATH):
        raise FileNotFoundError(
            "BRISQUE model/range files not found.\n"
            f"MODEL_PATH={MODEL_PATH}\nRANGE_PATH={RANGE_PATH}"
        )

    # ---------------------------------------------------------
    # 4. Compute BRISQUE score
    # ---------------------------------------------------------
    try:
        scorer = cv2.quality.QualityBRISQUE_create(MODEL_PATH, RANGE_PATH)
    except AttributeError as e:
        # Likely opencv-contrib not installed
        raise RuntimeError(
            "OpenCV 'quality' module not available. "
            "Please install opencv-contrib-python, not just opencv-python."
        ) from e

    # cv2.quality returns a 1-element array-like; take [0]
    score = float(scorer.compute(gray)[0])
    score_rounded = round(score, 4)
    score_bucket = _interpret_brisque(score)

    # ---------------------------------------------------------
    # 5. Prepare output
    # ---------------------------------------------------------
    if out_root is None:
        out_dir = os.path.join(PROJECT_ROOT, "outputs", "features", "brisque_outputs")
    else:
        out_dir = os.path.join(out_root, "features", "brisque_outputs")
    os.makedirs(out_dir, exist_ok=True)

    base = os.path.splitext(os.path.basename(image_path))[0]
    uid = uuid.uuid4().hex[:8]
    out_json = os.path.join(out_dir, f"{base}_brisque_{uid}.json")

    # 6. Save JSON
    data: Dict[str, Any] = {
        "tool": "BRISQUE",
        "tool_version": {
            "opencv": cv2.__version__,
            "python": sys.version.split()[0],
        },
        "image": {
            "original_path": image_path,
            "file_name": os.path.basename(image_path),
            "processed_shape": [int(h), int(w)],
            "dtype": "uint8",
            "channels": 1
        },
        "brisque_parameters_used": {
            "model_file": os.path.basename(MODEL_PATH),
            "range_file": os.path.basename(RANGE_PATH),
            "note": "Lower score = better perceptual quality"
        },
        "quality_score": score_rounded,
        "quality_bucket": score_bucket
    }

    with open(out_json, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2, ensure_ascii=False)

    return out_json, data

import { runBrisque, runPsnr, runSsim } from '../api';
import { markStartThenRunning, fetchFileFromUrl, getNodeImageUrl, updateNodeStatus, findInputImage } from './utils';
import type { Edge } from 'reactflow';
import type { RFNode, SetNodes } from './utils';
import type { CustomNodeData } from '../../types';

export async function runQuality(
  node: RFNode,
  setNodes: SetNodes,
  nodes: RFNode[],
  edges: Edge[]
) {
  const nodeId = node.id;
  const getIncoming = (id: string) => edges.filter((e) => e.target === id);

  // Helper: Throw & Update Fault
  const fail = async (msg: string) => {
    await updateNodeStatus(nodeId, 'fault', setNodes);
    throw new Error(msg); 
  };

  // -----------------------------------------------------
  // 🛡️ BRISQUE (ต้องการ Image บริสุทธิ์)
  // -----------------------------------------------------
  if (node.type === 'brisque') {
    const incoming = getIncoming(nodeId);
    if (incoming.length < 1) return fail('No image input');

    const prevNode = nodes.find((n) => n.id === incoming[0].source);
    
    // โหนดที่ไม่ควรเป็นต้นทางของ BRISQUE (เพราะให้ผลลัพธ์เป็น JSON/Descriptor/Binary)
    const BAD_SOURCES = ['sift', 'surf', 'orb', 'bfmatcher', 'flannmatcher', 'otsu', 'snake'];

    // ✅ FIX: Validation ดักจับโหนดที่ไม่ควรเชื่อมต่อ
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      return fail(`Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`);
    }

    const imgUrl = findInputImage(nodeId, nodes, edges);

    if (!imgUrl) return fail('Image URL not found for processing.');

    await markStartThenRunning(nodeId, 'Running BRISQUE', setNodes);

    try {
      // API call
      const resp = await runBrisque(imgUrl);

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: `BRISQUE = ${Number(resp.score).toFixed(2)}`,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    quality_score: resp.score,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'BRISQUE failed');
      return; 
    }
    return;
  }

  // -----------------------------------------------------
  // 🛡️ PSNR / SSIM (ต้องการ 2 Images)
  // -----------------------------------------------------
  if (node.type === 'psnr' || node.type === 'ssim') {
    const incoming = getIncoming(nodeId);
    const e1 = incoming.find((e) => e.targetHandle === 'input1');
    const e2 = incoming.find((e) => e.targetHandle === 'input2');

    if (!e1 || !e2) return fail('Need two image inputs (Input 1 & Input 2)');

    const nodeA = nodes.find((x) => x.id === e1.source);
    const nodeB = nodes.find((x) => x.id === e2.source);

    const urlA = getNodeImageUrl(nodeA);
    const urlB = getNodeImageUrl(nodeB);

    if (!urlA || !urlB) return fail('Image URL for one or both inputs missing.');

    await markStartThenRunning(nodeId, `Running ${node.type.toUpperCase()}`, setNodes);

    try {
      const fileA = await fetchFileFromUrl(urlA, 'a.jpg');
      const fileB = await fetchFileFromUrl(urlB, 'b.jpg');

      const runner = node.type === 'psnr' ? runPsnr : runSsim;
      const resp = await runner(fileA, fileB);

      const desc =
        node.type === 'psnr'
          ? `PSNR = ${Number(resp.quality_score ?? resp.score).toFixed(2)} dB`
          : `SSIM = ${Number(resp.score).toFixed(4)}`;

      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: desc,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'Metric failed');
      return;
    }
  }
}

import cv2
import numpy as np
import json
import os
import uuid
from typing import Dict, Any

def _read_json(path: str):
    if not os.path.exists(path):
        raise FileNotFoundError(f"JSON file not found: {path}")
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)

def run(match_json_path: str, out_root: str, warp_mode: str = "image2_to_image1", blend: bool = False):
    # 1. อ่านข้อมูลจาก Matcher JSON
    data = _read_json(match_json_path)

    # ✅ VALIDATION: ต้องมีตราประทับว่าเป็น Matcher เท่านั้น
    if "matching_tool" not in data:
        raise ValueError("Invalid input: Input file is not a Matcher result.")

    # 2. ดึง Path รูปภาพ (พร้อม Fallback)
    details = data.get("input_features_details", {})
    img1_info = details.get("image1", {})
    img2_info = details.get("image2", {})

    path1 = img1_info.get("original_path")
    path2 = img2_info.get("original_path")

    if not path1 or not path2:
        # Fallback to file_name if original_path is missing
        path1 = path1 or img1_info.get("file_name")
        path2 = path2 or img2_info.get("file_name")
        
        if not path1 or not path2:
            raise ValueError("Matcher JSON missing 'original_path'. Please re-run Feature & Matcher nodes.")

    # 3. โหลดรูปภาพ
    img1 = cv2.imread(path1)
    img2 = cv2.imread(path2)

    if img1 is None: raise FileNotFoundError(f"Cannot read image1: {path1}")
    if img2 is None: raise FileNotFoundError(f"Cannot read image2: {path2}")

    # 4. ดึงจุดที่ Match กัน
    matched_points = data.get("matched_points", [])
    if not (matched_points and len(matched_points) >= 4):
        raise ValueError("Matcher JSON must have at least 4 matched_points for Homography.")

    # 5. คำนวณ Homography
    src_pts = np.float32([m["pt2"] for m in matched_points]).reshape(-1, 1, 2) if warp_mode == "image2_to_image1" else np.float32([m["pt1"] for m in matched_points]).reshape(-1, 1, 2)
    dst_pts = np.float32([m["pt1"] for m in matched_points]).reshape(-1, 1, 2) if warp_mode == "image2_to_image1" else np.float32([m["pt2"] for m in matched_points]).reshape(-1, 1, 2)
    
    H, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
    
    inliers_count = int(mask.sum()) if mask is not None else 0

    if H is None:
         raise RuntimeError("Cannot compute homography matrix.")

    # 6. Warp Image
    if warp_mode == "image2_to_image1":
        h, w = img1.shape[:2]
        aligned = cv2.warpPerspective(img2, H, (w, h))
        base_for_blend = img1
    else:
        H_inv = np.linalg.inv(H)
        h2, w2 = img2.shape[:2]
        aligned = cv2.warpPerspective(img1, H_inv, (w2, h2))
        base_for_blend = img2

    if blend:
        if aligned.shape[:2] != base_for_blend.shape[:2]:
             aligned = cv2.resize(aligned, (base_for_blend.shape[1], base_for_blend.shape[0]))
        aligned = cv2.addWeighted(base_for_blend, 0.5, aligned, 0.5, 0)

    # 7. Save Result
    out_dir = os.path.join(out_root, "alignment", "homography_outputs")
    os.makedirs(out_dir, exist_ok=True)
    
    unique_id = uuid.uuid4().hex[:8]
    out_img_name = f"aligned_homo_{unique_id}.jpg"
    out_img_path = os.path.join(out_dir, out_img_name)
    out_json_path = os.path.join(out_dir, f"homography_{unique_id}.json")

    cv2.imwrite(out_img_path, aligned)

    result = {
        "tool": "HomographyAlignment",
        "warp_mode": warp_mode,
        "blend": blend,
        "num_inliers": inliers_count,
        "homography_matrix": H.tolist(),
        "output": {
            "aligned_image": out_img_path,
            "aligned_url": f"/static/alignment/homography_outputs/{out_img_name}"
        }
    }

    with open(out_json_path, "w", encoding="utf-8") as f:
        json.dump(result, f, indent=2, ensure_ascii=False)

    result["json_path"] = out_json_path
    return result

import cv2
import numpy as np
import json
import os
import uuid
from typing import Dict, Any

def _read_json(path: str):
    if not os.path.exists(path):
        raise FileNotFoundError(f"JSON file not found: {path}")
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)

def run(
    match_json_path: str, 
    out_root: str, 
    model: str = "affine", 
    warp_mode: str = "image2_to_image1", 
    blend: bool = False,
    ransac_thresh: float = 3.0,
    confidence: float = 0.99,
    refine_iters: int = 10
):
    # 1. อ่านข้อมูล
    data = _read_json(match_json_path)

    # ✅ VALIDATION: ต้องมีตราประทับว่าเป็น Matcher เท่านั้น
    if "matching_tool" not in data:
        raise ValueError("Invalid input: Input file is not a Matcher result.")

    # 2. ดึงข้อมูล Path รูปภาพ (พร้อม Fallback)
    details = data.get("input_features_details", {})
    img1_info = details.get("image1", {})
    img2_info = details.get("image2", {})

    path1 = img1_info.get("original_path")
    path2 = img2_info.get("original_path")

    if not path1 or not path2:
         # Fallback
         path1 = path1 or img1_info.get("file_name")
         path2 = path2 or img2_info.get("file_name")
         
         if not path1 or not path2:
            raise ValueError("Matcher JSON missing 'original_path'.")

    # 3. โหลดรูปภาพ
    img1 = cv2.imread(path1)
    img2 = cv2.imread(path2)
    
    if img1 is None: raise FileNotFoundError(f"Cannot read image1: {path1}")
    if img2 is None: raise FileNotFoundError(f"Cannot read image2: {path2}")

    # 4. ดึงจุดที่ Match กัน
    matched_points = data.get("matched_points", [])
    if not (matched_points and len(matched_points) >= 3):
         raise ValueError(f"Not enough points for Affine (need 3+, found {len(matched_points)})")

    src_pts = []
    dst_pts = []
    
    target_img = img1 
    source_img = img2 
    
    # จัดเตรียมจุดตาม Warp Mode
    for mp in matched_points:
        pt1 = mp["pt1"]
        pt2 = mp["pt2"]
        
        if warp_mode == "image2_to_image1":
            src_pts.append(pt2) 
            dst_pts.append(pt1)
            target_img = img1
            source_img = img2
        else:
            src_pts.append(pt1) 
            dst_pts.append(pt2)
            target_img = img2
            source_img = img1

    src_pts = np.float32(src_pts).reshape(-1, 1, 2)
    dst_pts = np.float32(dst_pts).reshape(-1, 1, 2)

    # 5. คำนวณ Affine Transform
    if model == "partial":
        M, inliers_mask = cv2.estimateAffinePartial2D(
            src_pts, dst_pts, 
            method=cv2.RANSAC, 
            ransacReprojThreshold=ransac_thresh, 
            confidence=confidence,
            refineIters=refine_iters
        )
        tool_used = "AffinePartial2D"
    else:
        M, inliers_mask = cv2.estimateAffine2D(
            src_pts, dst_pts, 
            method=cv2.RANSAC, 
            ransacReprojThreshold=ransac_thresh, 
            confidence=confidence,
            refineIters=refine_iters
        )
        tool_used = "Affine2D"

    inliers_count = int(inliers_mask.sum()) if inliers_mask is not None else 0

    if M is None:
         raise ValueError("Affine estimation failed.")

    # 6. Warp Image
    h, w = target_img.shape[:2]
    aligned = cv2.warpAffine(source_img, M, (w, h))

    # Blend (Optional)
    if blend:
        if aligned.shape[:2] != base_for_blend.shape[:2]:
             aligned = cv2.resize(aligned, (base_for_blend.shape[1], base_for_blend.shape[0]))
             
        aligned = cv2.addWeighted(target_img, 0.5, aligned, 0.5, 0)

    # 7. Save Result
    out_dir = os.path.join(out_root, "alignment", "affine_outputs")
    os.makedirs(out_dir, exist_ok=True)
    
    unique_id = uuid.uuid4().hex[:8]
    out_img_name = f"aligned_affine_{unique_id}.jpg"
    out_img_path = os.path.join(out_dir, out_img_name)
    out_json_name = f"affine_{unique_id}.json"
    out_json_path = os.path.join(out_dir, out_json_name)

    cv2.imwrite(out_img_path, aligned)

    result = {
        "tool": "AffineAlignment",
        "model": model,
        "warp_mode": warp_mode,
        "blend": blend,
        "num_inliers": inliers_count,
        "affine_matrix": M.tolist(),
        "output": {
            "aligned_image": out_img_path,
            "aligned_url": f"/static/alignment/affine_outputs/{out_img_name}"
        }
    }

    with open(out_json_path, "w", encoding="utf-8") as f:
        json.dump(result, f, indent=2, ensure_ascii=False)
        
    result["json_path"] = out_json_path
    return result

import { memo, useEffect, useMemo, useState, useCallback } from 'react';
import { Handle, Position, type NodeProps, useReactFlow, useEdges } from 'reactflow'; // ✅ ใช้ useEdges
import type { CustomNodeData } from '../../types';
import Modal from '../common/Modal';
import { abs } from '../../lib/api';

const dot = (active: boolean, cls: string) => 
  `h-4 w-4 rounded-full ${active ? cls : 'bg-gray-600'} flex-shrink-0`;

type Params = {
  model: 'affine' | 'partial';
  warp_mode: 'image2_to_image1' | 'image1_to_image2';
  blend: boolean;
  ransac_thresh: number;
  confidence: number;
  refine_iters: number;
};

const DEFAULT_PARAMS: Params = {
  model: 'affine',
  warp_mode: 'image2_to_image1',
  blend: false,
  ransac_thresh: 3.0,
  confidence: 0.99,
  refine_iters: 10,
};

const AffineAlignNode = memo(({ id, data, selected }: NodeProps<CustomNodeData>) => {
  const rf = useReactFlow();
  const edges = useEdges(); // ✅ Reactive edges
  const [open, setOpen] = useState(false);

  // ✅ Check connection
  const isConnected = useMemo(() => edges.some(e => e.target === id), [edges, id]);

  const savedParams = useMemo(() => {
    const p = (data?.payload?.params || {}) as Partial<Params>;
    return { ...DEFAULT_PARAMS, ...p };
  }, [data?.payload?.params]);

  const [form, setForm] = useState<Params>(savedParams);
  useEffect(() => setForm(savedParams), [savedParams]);

  const onClose = () => { setForm(savedParams); setOpen(false); };
  const onSave = () => {
    rf.setNodes((nds) =>
      nds.map((n) =>
        n.id === id
          ? {
              ...n,
              data: {
                ...n.data,
                payload: { ...(n.data?.payload || {}), params: { ...form } },
              },
            }
          : n
      )
    );
    setOpen(false);
  };

  const isRunning = data?.status === 'start' || data?.status === 'running';
  const isSuccess = data?.status === 'success';
  const isFault = data?.status === 'fault';

  const onRun = useCallback(() => {
    if (!isRunning) data?.onRunNode?.(id);
  }, [data, id, isRunning]);

  const resp = data?.payload?.json as any | undefined;
  const alignedUrl: string | undefined =
    (data?.payload?.aligned_url as string | undefined) ||
    (resp?.output?.aligned_url as string | undefined);

  const inliers = resp?.num_inliers;
  const model = (resp?.model as Params['model'] | undefined) ?? savedParams.model;
  const warpMode = (resp?.warp_mode as Params['warp_mode'] | undefined) ?? savedParams.warp_mode;
  const blend = typeof resp?.blend === 'boolean' ? resp.blend : savedParams.blend;

  // ✅ Theme: Purple (ม่วงเสมอ)
  let borderColor = 'border-purple-500';
  if (selected) {
    borderColor = 'border-purple-400 ring-2 ring-purple-500';
  } else if (isRunning) {
    borderColor = 'border-yellow-500 ring-2 ring-yellow-500/50';
  }

  // ✅ Handle Class Logic: แดงเฉพาะ Input (ซ้าย) เมื่อพังและไม่มีสาย
  const targetHandleClass = `w-2 h-2 rounded-full border-2 transition-all duration-300 ${
    isFault && !isConnected
      ? '!bg-red-500 !border-red-300 !w-4 !h-4 shadow-[0_0_10px_rgba(239,68,68,1)] ring-4 ring-red-500/30'
      : 'bg-white border-gray-500'
  }`;
  
  // Output (ขวา) ขาวเสมอ
  const sourceHandleClass = `w-2 h-2 rounded-full border-2 transition-all duration-300 bg-white border-gray-500`;

  return (
    <div className={`bg-gray-800 border-2 rounded-xl shadow-2xl w-88 max-w-sm text-gray-200 overflow-visible transition-all duration-200 ${borderColor}`}>
      
      {/* Input Handle (Left) */}
      <Handle 
        type="target" 
        position={Position.Left} 
        className={targetHandleClass} 
        style={{ top: '50%', transform: 'translateY(-50%)' }} 
      />
      
      {/* Output Handle (Right) */}
      <Handle 
        type="source" 
        position={Position.Right} 
        className={sourceHandleClass} 
        style={{ top: '50%', transform: 'translateY(-50%)' }} 
      />

      <div className="bg-gray-700 text-purple-500 rounded-t-xl px-2 py-2 flex items-center justify-between">
        <div className="font-bold">Affine Align</div>
        <div className="flex items-center gap-2">
          <button
            onClick={onRun}
            disabled={isRunning}
            // ✅ ปุ่มม่วงเสมอ
            className={[
              'px-2 py-1 rounded text-xs font-semibold transition-colors duration-200 text-white',
              isRunning
                ? 'bg-yellow-600 cursor-wait opacity-80'
                : 'bg-purple-600 hover:bg-purple-700',
            ].join(' ')}
          >
            {isRunning ? 'Running...' : '▶ Run'}
          </button>

          <button
            onClick={() => setOpen(true)}
            className="h-5 w-5 rounded-full bg-white flex items-center justify-center shadow ring-2 ring-gray-500/60 hover:ring-gray-500/80 transition-all"
          >
            <svg viewBox="0 0 24 24" className="h-3.5 w-3.5" fill="none" stroke="black">
              <g strokeLinecap="round" strokeLinejoin="round" strokeWidth={2.4}>
                <path d="M3 7h18" /> <circle cx="9" cy="7" r="3.4" fill="white" />
                <path d="M3 17h18" /> <circle cx="15" cy="17" r="3.4" fill="white" />
              </g>
            </svg>
          </button>
        </div>
      </div>

      <div className="p-4 space-y-3">
        <p className="text-sm text-gray-300">
          {alignedUrl ? `Alignment complete — ${inliers ?? '?'} inliers` : 'Connect a Matcher node and run'}
        </p>

        {alignedUrl && (
          <img
            src={abs(alignedUrl)}
            alt="affine-aligned"
            className="w-full rounded-lg border border-gray-700 shadow-md object-contain max-h-56"
            draggable={false}
          />
        )}

        <div className="mt-1 text-[11px] text-gray-300">
          <div className="mb-1">
            <span className="px-2 py-0.5 rounded bg-gray-900/70 border border-gray-700">
              Model: <span className="text-gray-100">{model}</span>
            </span>
          </div>
          <div className="flex flex-wrap gap-2">
            <span className="px-2 py-0.5 rounded bg-gray-900/70 border border-gray-700">
              Warp: <span className="text-gray-100">{warpMode}</span>
            </span>
            <span className="px-2 py-0.5 rounded bg-gray-900/70 border border-gray-700">
              Blend: <span className="text-gray-100">{blend ? 'ON' : 'OFF'}</span>
            </span>
          </div>
        </div>
      </div>

      <div className="border-t-2 border-gray-700 p-2 text-sm">
        <div className="flex justify-between items-center py-1">
          <span className="text-red-400">start</span>
          <div className={dot(data?.status === 'start', 'bg-red-500')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-cyan-400">running</span>
          <div className={dot(data?.status === 'running', 'bg-cyan-400 animate-pulse')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-green-400">success</span>
          <div className={dot(data?.status === 'success', 'bg-green-500')} />
        </div>
        <div className="flex justify-between items-center py-1">
          <span className="text-yellow-400">fault</span>
          <div className={dot(data?.status === 'fault', 'bg-yellow-500')} />
        </div>
      </div>

      <Modal open={open} title="Affine Settings" onClose={onClose}>
        <div className="space-y-3 text-xs text-gray-300">
          <label>
            Model
            <select
              className="w-full mt-1 px-2 py-1 rounded bg-gray-900 border border-gray-700 text-gray-100"
              value={form.model}
              onChange={(e) =>
                setForm((s) => ({
                  ...s,
                  model: e.target.value as Params['model'],
                }))
              }
            >
              <option value="affine">Affine</option>
              <option value="partial">Partial</option>
            </select>
          </label>
          {/* (Params อื่นๆ คงเดิม) */}
          <div className="flex justify-end gap-2 pt-3">
            <button
              onClick={onClose}
              className="px-3 py-1 rounded bg-gray-700 text-gray-200 hover:bg-gray-600"
            >
              Close
            </button>
            <button
              onClick={onSave}
              className="px-3 py-1 rounded bg-purple-600 text-white hover:bg-purple-700"
            >
              Save
            </button>
          </div>
        </div>
      </Modal>
    </div>
  );
});

export default AffineAlignNode;

import { runBrisque, runPsnr, runSsim } from '../api';
import { markStartThenRunning, fetchFileFromUrl, getNodeImageUrl, updateNodeStatus } from './utils';
import type { Edge } from 'reactflow';
import type { RFNode, SetNodes } from './utils';
import type { CustomNodeData } from '../../types';

export async function runQuality(
  node: RFNode,
  setNodes: SetNodes,
  nodes: RFNode[],
  edges: Edge[]
) {
  const nodeId = node.id;
  const getIncoming = (id: string) => edges.filter((e) => e.target === id);

  // Helper: Throw & Update Fault (ไม่ต้องเป็น async/await ในการเรียกใช้)
  const fail = (msg: string) => {
    updateNodeStatus(nodeId, 'fault', setNodes);
    throw new Error(msg); 
  };

  // -----------------------------------------------------
  // 🛡️ BRISQUE (ต้องการ Image บริสุทธิ์)
  // -----------------------------------------------------
  if (node.type === 'brisque') {
    const incoming = getIncoming(nodeId);
    if (incoming.length < 1) return fail('No image input'); // ❌ No 'await' needed here

    const prevNode = nodes.find((n) => n.id === incoming[0].source);
    
    const BAD_SOURCES = ['sift', 'surf', 'orb', 'bfmatcher', 'flannmatcher', 'otsu', 'snake'];

    // Validation: ดักจับ Feature/Matcher/Classification
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      return fail(`Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`);
    }

    const imgUrl = findInputImage(nodeId, nodes, edges);

    if (!imgUrl) return fail('Image URL not found for processing.');

    await markStartThenRunning(nodeId, 'Running BRISQUE', setNodes);

    try {
      const resp = await runBrisque(imgUrl);

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: `BRISQUE = ${Number(resp.score).toFixed(2)}`,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    quality_score: resp.score,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      fail(err?.message || 'BRISQUE failed'); // ❌ No 'await'
    }
    return; // ❌ ไม่ต้องมี return เปล่า ถ้าไม่มี Logic อื่นต่อ
  }

  // -----------------------------------------------------
  // 🛡️ PSNR / SSIM (ต้องการ 2 Images)
  // -----------------------------------------------------
  if (node.type === 'psnr' || node.type === 'ssim') {
    const incoming = getIncoming(nodeId);
    const e1 = incoming.find((e) => e.targetHandle === 'input1');
    const e2 = incoming.find((e) => e.targetHandle === 'input2');

    if (!e1 || !e2) return fail('Need two image inputs (Input 1 & Input 2)');

    const nodeA = nodes.find((x) => x.id === e1.source);
    const nodeB = nodes.find((x) => x.id === e2.source);

    const urlA = getNodeImageUrl(nodeA);
    const urlB = getNodeImageUrl(nodeB);

    if (!urlA || !urlB) return fail('Image URL for one or both inputs missing.');

    await markStartThenRunning(nodeId, `Running ${node.type.toUpperCase()}`, setNodes);

    try {
      const fileA = await fetchFileFromUrl(urlA, 'a.jpg');
      const fileB = await fetchFileFromUrl(urlB, 'b.jpg');

      const runner = node.type === 'psnr' ? runPsnr : runSsim;
      const resp = await runner(fileA, fileB);

      const desc =
        node.type === 'psnr'
          ? `PSNR = ${Number(resp.quality_score ?? resp.score).toFixed(2)} dB`
          : `SSIM = ${Number(resp.score).toFixed(4)}`;

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: desc,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      fail(err?.message || 'Metric failed');
    }
  }
}

// src/lib/runners/utils.tsx
import { abs } from '../api';
import type { Dispatch, SetStateAction, MutableRefObject } from 'react';
import type { Node, Edge } from 'reactflow';
import type { CustomNodeData } from '../../types';

// ====== Typed aliases ======
export type RFNode = Node<CustomNodeData>;
export type SetNodes = Dispatch<SetStateAction<RFNode[]>>;

/**
 * 🟢 markStartThenRunning
 */
export async function markStartThenRunning(
  nodeId: string,
  label: string,
  setNodes: SetNodes
) {
  setNodes((nds) =>
    nds.map((x) =>
      x.id === nodeId
        ? { ...x, data: { ...x.data, status: 'start', description: `Start ${label}` } }
        : x
    )
  );

  await new Promise((r) => setTimeout(r, 200));

  setNodes((nds) =>
    nds.map((x) =>
      x.id === nodeId
        ? { ...x, data: { ...x.data, status: 'running', description: `Running ${label}` } }
        : x
    )
  );
}

/**
 * ✅ updateNodeStatus (สำหรับเปลี่ยนสี Node เป็น Fault/Success)
 */
export async function updateNodeStatus(
  nodeId: string,
  status: 'idle' | 'running' | 'start' | 'success' | 'fault', 
  setNodes: SetNodes
) {
  setNodes((nds) =>
    nds.map((n) => {
      if (n.id === nodeId) {
        return { ...n, data: { ...n.data, status: status } };
      }
      return n;
    })
  );
  await new Promise((r) => setTimeout(r, 50));
}

/**
 * ✅ findInputImage (FIXED: ฟังก์ชันที่ Quality Node ต้องการ)
 * หา Path/URL ของรูปภาพจาก upstream node
 */
export function findInputImage(
  nodeId: string, 
  nodes: RFNode[], 
  edges: Edge[]
): string | undefined { // เปลี่ยนจาก string | null เป็น string | undefined 
  const incoming = edges.find(e => e.target === nodeId);
  if (!incoming) return undefined;

  const parent = nodes.find(n => n.id === incoming.source);
  if (!parent || !parent.data) return undefined;

  const data = parent.data.payload || parent.data.output;
  if (!data) return undefined;
  
  // 1. String Path ตรงๆ
  if (typeof data === 'string') return data;

  // 2. Object (เช็ค URL รูปภาพหลักๆ ที่ Runner ใช้)
  if (typeof data === 'object') {
     return (data as any).url || 
            (data as any).aligned_url || 
            (data as any).path || 
            (data as any).image_path ||
            (data as any).saved_path || 
            (data as any).vis_url || 
            (data as any).binary_url || 
            (data as any).result_image_url || 
            undefined;
  }
  return undefined;
}

/**
 * 📂 fetchFileFromUrl
 * โหลดภาพจาก URL แล้วคืนค่าเป็น File object (สำหรับ PSNR/SSIM)
 */
export async function fetchFileFromUrl(url: string, filename: string): Promise<File> {
  if (!url) throw new Error('Missing URL');
  const resp = await fetch(url);
  if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
  const blob = await resp.blob();
  return new File([blob], filename, { type: blob.type || 'image/jpeg' });
}

/**
 * 🧭 getNodeImageUrl (ใช้ใน PSNR/SSIM เพื่อดึง URL สำหรับแสดงผล)
 */
export function getNodeImageUrl(n?: RFNode): string | undefined {
  if (!n) return undefined;
  const normalize = (u?: string) => u ? (/^(https?:|blob:|data:)/i.test(u) ? u : abs(u)) : undefined;

  if (n.type === 'image-input') {
    return normalize(n.data?.payload?.url) ?? normalize(n.data?.payload?.preview_url);
  }
  if (['sift', 'surf', 'orb'].includes(n.type || '')) {
    return normalize(n.data?.payload?.result_image_url) ?? normalize(n.data?.payload?.vis_url);
  }
  if (['bfmatcher', 'flannmatcher'].includes(n.type || '')) {
    return normalize(n.data?.payload?.vis_url);
  }
  if (['homography-align', 'affine-align'].includes(n.type || '')) {
    const p = n.data?.payload as any;
    return normalize(p?.output?.aligned_url) ?? normalize(p?.aligned_url);
  }
  return normalize(n.data?.payload?.result_image_url) ?? normalize(n.data?.payload?.url);
}

/**
 * 🧰 guard
 */
export function guard(canceledRef: MutableRefObject<boolean>) {
  if (canceledRef.current) throw new Error('Pipeline canceled');
}

// src/lib/runners/utils.tsx
import { abs } from '../api';
import type { Dispatch, SetStateAction, MutableRefObject } from 'react';
import type { Node, Edge } from 'reactflow';
import type { CustomNodeData, NodeStatus } from '../../types';

// ====== Typed aliases ======
export type RFNode = Node<CustomNodeData>;
export type SetNodes = Dispatch<SetStateAction<RFNode[]>>;

/**
 * 🟢 markStartThenRunning
 * อัปเดตสถานะของโหนดให้แสดงผล Start → Running
 */
export async function markStartThenRunning(
  nodeId: string,
  label: string,
  setNodes: SetNodes
) {
  setNodes((nds) =>
    nds.map((x) =>
      x.id === nodeId
        ? { ...x, data: { ...x.data, status: 'start', description: `Start ${label}` } }
        : x
    )
  );

  await new Promise((r) => setTimeout(r, 200));

  setNodes((nds) =>
    nds.map((x) =>
      x.id === nodeId
        ? { ...x, data: { ...x.data, status: 'running', description: `Running ${label}` } }
        : x
    )
  );
}

/**
 * ✅ updateNodeStatus (สำหรับเปลี่ยนสี Node เป็น Fault/Success)
 */
export async function updateNodeStatus(
  nodeId: string,
  status: NodeStatus, // ใช้ type NodeStatus จาก types.ts
  setNodes: SetNodes
) {
  setNodes((nds) =>
    nds.map((n) => {
      if (n.id === nodeId) {
        return { ...n, data: { ...n.data, status: status } };
      }
      return n;
    })
  );
  await new Promise((r) => setTimeout(r, 50));
}

/**
 * ✅ findInputImage (FIXED: ฟังก์ชันที่ Quality Node ต้องการ)
 * หา Path/URL ของรูปภาพที่สะอาดจาก upstream node
 */
export function findInputImage(
  nodeId: string, 
  nodes: RFNode[], 
  edges: Edge[]
): string | undefined {
  const incoming = edges.find(e => e.target === nodeId);
  if (!incoming) return undefined;

  const parent = nodes.find(n => n.id === incoming.source);
  if (!parent || !parent.data) return undefined;

  // โหนดที่มี output เป็นรูปภาพ หรือ URL
  const data = parent.data.payload || parent.data.output;
  if (!data) return undefined;
  
  // 1. String Path ตรงๆ
  if (typeof data === 'string') return data;

  // 2. Object (เช็ค URL รูปภาพหลักๆ)
  if (typeof data === 'object') {
     return (data as any).url || 
            (data as any).aligned_url || 
            (data as any).path || 
            (data as any).image_path ||
            (data as any).saved_path || 
            (data as any).vis_url || 
            (data as any).binary_url || 
            (data as any).result_image_url || 
            undefined;
  }
  return undefined;
}

/**
 * 📂 fetchFileFromUrl
 * โหลดภาพจาก URL แล้วคืนค่าเป็น File object (สำหรับ PSNR/SSIM)
 */
export async function fetchFileFromUrl(url: string, filename: string): Promise<File> {
  if (!url) throw new Error('Missing URL');
  const resp = await fetch(url);
  if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
  const blob = await resp.blob();
  return new File([blob], filename, { type: blob.type || 'image/jpeg' });
}

/**
 * 🧭 getNodeImageUrl (ใช้ใน PSNR/SSIM เพื่อดึง URL สำหรับแสดงผล)
 */
export function getNodeImageUrl(n?: RFNode): string | undefined {
  if (!n) return undefined;
  // abs() function for converting relative path to absolute URL
  const normalize = (u?: string) => u ? (/^(https?:|blob:|data:)/i.test(u) ? u : abs(u)) : undefined;

  const p = n.data?.payload as any;

  // Priority based on output types
  if (n.type === 'image-input') {
    return normalize(p?.url) ?? normalize(p?.preview_url);
  }
  if (['sift', 'surf', 'orb'].includes(n.type || '')) {
    // Feature nodes output visualization
    return normalize(p?.result_image_url) ?? normalize(p?.vis_url);
  }
  if (['bfmatcher', 'flannmatcher'].includes(n.type || '')) {
    return normalize(p?.vis_url);
  }
  if (['homography-align', 'affine-align'].includes(n.type || '')) {
    return normalize(p?.output?.aligned_url) ?? normalize(p?.aligned_url);
  }

  // Fallback
  return normalize(p?.result_image_url) ?? normalize(p?.url);
}

/**
 * 🧰 guard
 */
export function guard(canceledRef: MutableRefObject<boolean>) {
  if (canceledRef.current) throw new Error('Pipeline canceled');
}

import { runBrisque, runPsnr, runSsim } from '../api';
import { markStartThenRunning, fetchFileFromUrl, getNodeImageUrl, updateNodeStatus, findInputImage } from './utils';
import type { Edge } from 'reactflow';
import type { RFNode, SetNodes } from './utils';
import type { CustomNodeData } from '../../types';

// -----------------------------------------------------
// 💡 The 'export' keyword was missing here!
// -----------------------------------------------------
export async function runQuality( // ✅ แก้ไข: เพิ่ม export
  node: RFNode,
  setNodes: SetNodes,
  nodes: RFNode[],
  edges: Edge[]
) {
  const nodeId = node.id;
  const getIncoming = (id: string) => edges.filter((e) => e.target === id);

  // Helper: Throw & Update Fault (defined here to access scope)
  const fail = async (msg: string) => {
    await updateNodeStatus(nodeId, 'fault', setNodes);
    throw new Error(msg); 
  };

  // -----------------------------------------------------
  // 🛡️ BRISQUE
  // -----------------------------------------------------
  if (node.type === 'brisque') {
    const incoming = getIncoming(nodeId);
    if (incoming.length < 1) return fail('No image input');

    const prevNode = nodes.find((n) => n.id === incoming[0].source);
    
    const BAD_SOURCES = ['sift', 'surf', 'orb', 'bfmatcher', 'flannmatcher', 'otsu', 'snake'];

    // Validation: ดักจับโหนดที่ไม่ควรเชื่อมต่อ
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      return fail(`Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`);
    }

    const imgUrl = findInputImage(nodeId, nodes, edges);

    if (!imgUrl) return fail('Image URL not found for processing.');

    await markStartThenRunning(nodeId, 'Running BRISQUE', setNodes);

    try {
      const resp = await runBrisque(imgUrl);

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: `BRISQUE = ${Number(resp.score).toFixed(2)}`,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    quality_score: resp.score,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'BRISQUE failed');
      return; 
    }
    return;
  }

  // -----------------------------------------------------
  // 🛡️ PSNR / SSIM
  // -----------------------------------------------------
  if (node.type === 'psnr' || node.type === 'ssim') {
    const incoming = getIncoming(nodeId);
    const e1 = incoming.find((e) => e.targetHandle === 'input1');
    const e2 = incoming.find((e) => e.targetHandle === 'input2');

    if (!e1 || !e2) return fail('Need two image inputs (Input 1 & Input 2)');

    const nodeA = nodes.find((x) => x.id === e1.source);
    const nodeB = nodes.find((x) => x.id === e2.source);

    const urlA = getNodeImageUrl(nodeA);
    const urlB = getNodeImageUrl(nodeB);

    if (!urlA || !urlB) return fail('Image URL for one or both inputs missing.');

    await markStartThenRunning(nodeId, `Running ${node.type.toUpperCase()}`, setNodes);

    try {
      const fileA = await fetchFileFromUrl(urlA, 'a.jpg');
      const fileB = await fetchFileFromUrl(urlB, 'b.jpg');

      const runner = node.type === 'psnr' ? runPsnr : runSsim;
      const resp = await runner(fileA, fileB);

      const desc =
        node.type === 'psnr'
          ? `PSNR = ${Number(resp.quality_score ?? resp.score).toFixed(2)} dB`
          : `SSIM = ${Number(resp.score).toFixed(4)}`;

      // Success
      setNodes((nds) =>
        nds.map((x) =>
          x.id === nodeId
            ? {
                ...x,
                data: {
                  ...x.data,
                  status: 'success',
                  description: desc,
                  payload: {
                    ...(x.data as CustomNodeData)?.payload,
                    json: resp,
                    output: resp
                  },
                } as CustomNodeData,
              }
            : x
        )
      );
    } catch (err: any) {
      await fail(err?.message || 'Metric failed');
      return;
    }
  }
}

# ... (ภายใน if image_path.lower().endswith(".json"): ) ...
            
            if tool:
                # แก้ไขข้อความ Error ให้เป็นภาษาที่เข้าใจง่ายขึ้น
                raise ValueError(
                    f"Invalid Input: File came from '{tool}'. "
                    "This node strictly requires a clean Image file (JPG/PNG/etc.) to assess quality."
                )
# ...

    # ...
    img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
    
    # ❌ แก้ไขข้อความนี้
    if img is None:
        raise ValueError(f"Cannot read image file. Check path/file integrity: {image_path}")

    # ...

// src/lib/runners/quality.tsx (ภายใน runQuality, case 'brisque')

// ...
    // ✅ FIX: Validation ดักจับโหนดที่ไม่ควรเชื่อมต่อ
    if (prevNode && BAD_SOURCES.includes(prevNode.type || '')) {
      const tool = prevNode.type;
      
      // ⬇️⬇️ ปรับข้อความตรงนี้ ⬇️⬇️
      return fail(
        `Invalid Input: BRISQUE requires a clean image source (Image Input or Alignment result), not a '${tool}' result.`
        // หรือถ้าอยากให้เป็นภาษาไทยที่ชัดเจนขึ้น:
        // `BRISQUE รับ Input ที่มาจาก ${tool.toUpperCase()} ไม่ได้ครับ. กรุณาเชื่อมต่อ Source Image เท่านั้น`
      );
    }
// ...